We didn’t get into software to babysit CI pipelines or chase down null pointers. We became developers to invent—to take an idea, will it into existence, and watch as it comes alive. But over time, the spark can dim. The backlog grows. Alerts stack up. Pull requests blur together. What once felt like magic starts to feel like maintenance.

It’s time to change that. With AI agents as teammates, we can offload the busywork, reclaim our flow, and get back to what we love: building things that matter.

At Microsoft Build last week, we introduced a fundamental shift in how development teams can work: Agentic DevOps – which is shorthand for a new approach where AI agents work alongside your team throughout the entire software development lifecycle. Unlike the autocomplete and suggestions you might be familiar with in GitHub Copilot, these are autonomous agents that can take on entire classes of tasks with your guidance and approval.

This post provides an illustrative, step-by-step overview of modern software development with agentic tools along the journey as we build the Octopets app, which is envisioned as an app that helps pet owners find pet-friendly locations and connect with other pet owners.

Each phase of the development lifecycle is covered – from idea to implementation to iteration to deployment, monitoring, and modernization – to demonstrate how these tools transform the developer experience.

Here’s a quick look at the tools that we’ll cover in this post:

• GitHub Copilot on GitHub.com
• GitHub Copilot coding agent
• GitHub Copilot agent mode
• Model Context Protocol servers
• Azure SRE agent
• GitHub Copilot app modernization – Upgrade for .NET and Java

Phase 1: From idea to code – Turning concepts into reality

Ideation with Copilot on GitHub.com

That initial spark of an idea can turn into something magical, and using GitHub Copilot on GitHub.com gives you access from anywhere to bring that idea to life. The Octopets project began here all with a single prompt in GitHub.com which evolved our idea into a full PRD (product requirements document).

Can you make me a prototype landing page for a “Meetup” for pet-friendly locations for pet owners?

From this PRD, we were then able to generate and iterate on that landing page for our product pitch:

From this single prompt, Copilot generated:

• A complete product requirements document
• A responsive landing page prototype
• User journey mapping
• Initial tech stack recommendations

This phase took minutes rather than days, providing the team with a clear starting point for refinement. By taking the same PRD directly into VS Code with GitHub Copilot agent mode, it is now possible to refine using different models on our local development machine to achieve the desired landing page. Agent mode can scaffold out the project, iterate with us, resolve issues, and start a local server to host our application.

Phase 2: Copilot coding agent joins the team

With our initial prototype ready, we can proceed with the project. Our engineers enhance the landing page by adding a full .NET web API backend and .NET Aspire orchestration for real-time insights. As the app grows, the feature backlog increases. GitHub Copilot coding agent helps by implementing new features, fixing bugs, or handling other tasks.

A new branch is created alongside a draft pull request for us to review and iterate with Copilot to give it feedback. Here we can see a new implementation for the pet profile where Copilot will work across our frontend and backend to implement the feature:

The first iteration that Copilot worked on turned out pretty great, but we wanted a few tweaks, so just like any code review we gave Copilot feedback to take and work on a new iteration. This can be done at a high level or as a full code review line by line:

With the new iteration complete we can test out the pull request branch locally to verify the changes before merging:

This workflow allows developers to delegate tasks to Copilot, integrating it as a valuable member of the team. Copilot can be entrusted with various work items and will promptly commence its duties, enabling developers to concentrate on their primary responsibilities.

Phase 3: Design-to-code with Figma integration

As the project progressed, our design team created detailed Figma mockups. They then planned new features and updates using GitHub issues. With Model Context Protocol (MCP) support, we enhanced GitHub Copilot’s agent mode with new tools. Now, we can easily query GitHub issues for any linked Figma files:

The integration of Figma with GitHub Copilot through the Figma’s Dev Mode MCP server allows users to query and initiate design directly within their code editor. This integration enables GitHub Copilot agent mode to comprehend and implement design changes into the code. By initiating an issue, Copilot retrieves the issue description, connects with the Figma’s Dev Mode MCP server for the design, and generates the necessary code to realize the design.

And just like that our designer’s vision has been brought to life in this component with proper components, styles, and more:

This approach bridged the gap between design and development, eliminating the time-consuming handoff process. Designers could iterate in their preferred tools while developers focused on business logic and functionality, with the agent handling the implementation details.

Phase 4: End-to-end testing with Playwright

As our engineering team and GitHub Copilot work on Octopets, finalizing the design and implementing features, maintaining high quality and avoiding regressions is essential. End-to-end tests with Playwright are important for testing the application’s main user flows. Developers can use Playwright’s API to create and run test scripts with its deep VS Code integration, but Playwright MCP server now allows testers or quality engineers to create tests using natural language, without needing access to the code.

Simply configure the Playwright MCP server with GitHub Copilot agent mode and new tools are available to you to have Playwright start exploring your site and creating tests. With a prompt file, Copilot and Playwright get to work:

Combining the power of GitHub Copilot agent mode, now available across VS Code, Visual Studio, Xcode, Eclipse, and Jetbrains IDEs and Model Context Protocol servers unlocks a world of possibilities and productivity like never before seen.

Phase 5: Monitoring – Ensuring application health

Shortly after deployment, the Octopets platform experienced its first production incident. The SRE Agent in Azure has fundamentally changed how the team handled this event.

On a Saturday morning, the SRE Agent detected an API returning 500 errors. Here’s what happened next:

1. The SRE Agent detected exceptions in the API causing HTTP 500 responses
2. These errors triggered alerts in Azure Monitor
3. It then automatically created a detailed GitHub issue with all relevant logs
4. The agent began autonomous troubleshooting while notifying the team
5. It auto scales our API in Azure Container Apps to get our site back up and running
6. Within minutes, it identified the root cause and proposed a fix on GitHub

// SRE Agent: 500 errors detected in Octopets pet-locations-api service
// Time: Saturday, 6:17 AM
// Action: Analyzed logs and identified NullReferenceException in location validation code
// Root cause: Incorrect handling of null coordinates in location filter
// Resolution: Applied hotfix to properly validate location parameters before processing
// Status: Deployed to production, error rate returned to normal
// GitHub Issue #4728 created with full incident report and fix details

Instead of having their weekend plans derailed, the team received a notification that an issue was detected, analyzed, fixed, and documented—all without human intervention. The agent created a GitHub Issue with complete details so the team could review what happened and consider longer-term solutions during regular working hours.

Previously, resolving issues involved acknowledging alerts, connecting to VPN, analyzing logs, and manual fixes, often taking hours. The SRE Agent now completes these tasks in minutes with minimal human involvement. It improves autonomously by learning from the team’s incident resolution patterns.

Phase 6: Modernization – Keeping the codebase current

Modernizing acquired legacy code

As the Octopets platform gained popularity, the team acquired a small Pet Treat distribution company that utilized a legacy .NET API requiring integration. Instead of dedicating weeks to manually updating the outdated codebase, they employed the new GitHub Copilot app modernization – Upgrade for .NET to facilitate the migration.

The agent:

1. Analyzed the entire codebase
2. Updated all dependencies to latest versions
3. Migrated from .NET Framework to .NET 9
4. Improved security, performance, and maintainability
5. Preserved all business logic during the upgrade

This wasn’t just a simple copy-paste job. The agent:

1. Identified the legacy connection management pattern and replaced it with modern dependency injection
2. Converted synchronous code to async/await patterns for better scalability
3. Added proper error handling and logging for production readiness
4. Identified security vulnerabilities and obsolete classes and methods
5. Upgrade NuGet packages and simplified dependency management
6. Integrated with modern .NET features like minimal APIs and built-in DI container
7. Preserved the original business logic while improving the architecture

The entire process took minutes instead of days, and all tests passed on the first try.

The software development lifecycle reimagined

Throughout the Octopets project, GitHub Copilot with Agent mode significantly enhanced every stage of the development lifecycle:

Get Started Today

Are you prepared to reimage your DevOps tasks and developer lifecycle? Here’s how to begin:

Check out these Build sessions for further information.

• BRK100: Reimagining Software Development and DevOps with Agentic AI
• BRK113: The Agent Awakens: Collaborative Development with GitHub Copilot
• BRK118: Accelerate Azure Development with GitHub Copilot, VS Code & AI
• BRK131: Java App Modernization Simplified with AI
• BRK101: The Future of .NET App Modernization Streamlined with AI
• BRK102: Agent Mode in Action: AI Coding with Vibe and Spec-Driven Flows

Take action now:

• Try GitHub Copilot with Agent mode in your preferred editor—whether that’s Visual Studio, VS Code, or other supported IDEs. Start a free trial if you’re not already a subscriber.
• Explore our comprehensive documentation on creating custom agents for your specific workflow needs.
• Join the DevOps Agents Community to share experiences and learn best practices from other developers.

Rediscovering the joy of development

As someone who’s been in software development for decades, we’ve seen how the increasing complexity of systems has gradually shifted our work away from creation and toward maintenance. What excites us most about agentic DevOps is the potential to reverse this trend—to let machines handle the routine while humans focus on innovation.

This isn’t about replacing developers. It’s about elevating the role of the developer to focus on what humans do best: creative problem-solving, architectural thinking, and designing experiences that delight users.

GitHub Copilot is your path out of the grind. In the old world, software development was a long, slow relay—weeks to plan, months to build, quarters to launch. Today, agents help you build faster, crush your backlog, cancel tech debt, secure your apps, and keep it all running in production—with you directing the orchestra.

Whether you’re maintaining legacy systems or building new cloud-native applications, these new capabilities help you reclaim time for what matters. Because at the end of the day, we became developers to build—not to maintain, not to fix, but to create.

What would you do with an extra 20 hours a week? What could your team build if they weren’t constantly putting out fires? We can’t wait to see what you create when you delegate the drudgery to your new AI teammates.